package com.cnd.scm.orm.accessfilter;

import java.util.ArrayList;
import java.util.Map;

/**
 * 这个类作为查询条件构造器，帮助其维护关于查询中过滤条件的信息（条件构造器）
 * @author 李启联
 *
 */
public class AccessFilter {


    protected final ArrayList filters = new ArrayList();

	/**
	 * 清空过滤条件
	 */
	public void cleanFilter(){
		this.filters.clear();
	}
	

    /**
     * 增加一个相等(EQUAL)过滤条件
     * @param andCondition 使用 and 或者 or 条件
     * @param filterKey    过滤字段
     * @param filterValue  过滤值
     * @return  AND FILTERKEY = 'FILTERVALUE' 或者 OR FILTERKEY = 'FILTERVALUE'
     */
    public AccessFilter addEqual(boolean andCondition, String filterKey, Object filterValue){
       this.filters.add(new AccessFilterEqualItem(andCondition,filterKey, filterValue));
       return this;
    }
    /**
     * 增加一个相等(EQUAL)过滤条件,默认使用 and 条件拼接
     * @param filterKey    过滤字段
     * @param filterValue 过滤值
     * @return  AND FILTERKEY = 'FILTERVALUE'
     */
    public AccessFilter addEqual(String filterKey, Object filterValue){
        return addEqual(true,filterKey, filterValue);
    }
    
    /**
     * 增加一个相等或為空(EqualOrIsNull)的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey     过滤字段
     * @param filterValue   过滤值
     * @return AND (FILTERKEY = 'FILTERVALUE' OR FILTERKEY IS NULL ) 或者 OR (FILTERKEY = 'FILTERVALUE' OR FILTERKEY IS NULL )
     */
    public AccessFilter addEqualOrIsNull(boolean andCondition, String filterKey, Object filterValue){
        this.filters.add(new AccessFilterEqualOrIsNullItem(andCondition, filterKey, filterValue));
        return this;
    }
    /**
     * 增加一个相等或為空(EqualOrIsNull)的过滤条件,默认使用 and 条件拼接
     * @param filterKey  过滤字段
     * @param filterValue 过滤值
     * @return AND (FILTERKEY = 'FILTERVALUE' OR FILTERKEY IS NULL )
     */
    public AccessFilter addEqualOrIsNull(String filterKey, Object filterValue){
        return addEqualOrIsNull(true, filterKey, filterValue);
    }
    
    /**
     * 增加一个是否为DBNull的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey 过滤字段
     * @param isOrNotNull 否则为 null
     * @return 当isOrNotNull 为 true 时 ： is null ; 否则为： is not null
     */
    public AccessFilter addIsDBNull(boolean andCondition, String filterKey, boolean isOrNotNull ){
        this.filters.add(new AccessFilterIsDBNullItem(andCondition, filterKey, isOrNotNull));
        return this;
    }
    /**
     * 增加一个是否为DBNull的过滤条件,默认使用 and 条件拼接
     * @param filterKey 过滤字段
     * @param isOrNotNull 否则为 null
     * @return 当isOrNotNull 为 true 时 ： is null ; 否则为： is not null
     */
    public AccessFilter addIsDBNull(String filterKey, boolean isOrNotNull ){
        return addIsDBNull(true, filterKey, isOrNotNull);
    }
    
    /**
     * 增加一个是否为 DBNull Or StringEmpty的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey  过滤字段
     * @param isDBNullOrStringEmpty is null 或者 is not null
     * @return and 或者 or  (filterKey = '' or filterKey is null) 或 (filterKey <> '' or filterKey is not null)
     */
    public AccessFilter addIsDBNullOrStringEmpty(boolean andCondition,String filterKey, boolean isDBNullOrStringEmpty){
    	this.filters.add(new AccessFilterIsDBNullOrStringEmptyItem(andCondition, filterKey, isDBNullOrStringEmpty));
        return this;
    }
    /**
     * 增加一个是否为 DBNull Or StringEmpty的过滤条件,默认使用 and 条件拼接
     * @param filterKey 过滤字段
     * @param isDBNullOrStringEmpty  为 true 时: (filterKey = '' or filterKey is null) ; 否则为：filterKey <> '' or filterKey is not null)
     * @return
     */
    public AccessFilter addIsDBNullOrStringEmpty(String filterKey, boolean isDBNullOrStringEmpty){
        return addIsDBNullOrStringEmpty(true,filterKey,isDBNullOrStringEmpty);
    }

    
    /**
     * 增加一个小于的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey 过滤字段
     * @param filterValue 过滤值
     * @return and 或者 or  filterKey < 'filterValue'
     */
    public AccessFilter addLessThen(boolean andCondition, String filterKey, Object filterValue){
    	this.filters.add(new AccessFilterLessThenItem(andCondition,filterKey, filterValue));
        return this;
    }

    /**
     * 增加一个小于的过滤条件,默认使用 and 条件拼接
     * @param filterKey 过滤字段
     * @param filterValue 过滤值
     * @return and filterKey < 'filterValue'
     */
    public AccessFilter addLessThen(String filterKey, Object filterValue){
        return addLessThen(true,filterKey,filterValue);
    }
    
    /**
     * 增加一个小于等于的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey  过滤字段
     * @param filterValue 过滤值
     * @return and 或者 or  filterKey <= 'filterValue'
     */
    public AccessFilter addLessThenAndEqual(boolean andCondition, String filterKey, Object filterValue){
    	this.filters.add(new AccessFilterLessThenAndEqualItem(andCondition,filterKey, filterValue));
        return this;
    }
    /**
     * 增加一个小于等于的过滤条件,默认使用 and 条件拼接
     * @param filterKey 过滤字段
     * @param filterValue 过滤值
     * @return and filterKey <= 'filterValue'
     */
    public AccessFilter addLessThenAndEqual(String filterKey, Object filterValue){
        return addLessThenAndEqual(true,filterKey,filterValue);
    }

    
    /**
     * 增加一个大于的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey   过滤字段
     * @param filterValue 过滤值
     * @return and 或者 or filterKey > 'filterValue'
     */
    public AccessFilter addGreaterThan(boolean andCondition, String filterKey,Object filterValue){
    	this.filters.add(new AccessFilterGreaterThanItem(andCondition,filterKey, filterValue));
        return this;
    }
    /**
     * 增加一个大于的过滤条件,默认使用 and 条件拼接
     * @param filterKey   过滤字段
     * @param filterValue 过滤值
     * @return and filterKey > 'filterValue'
     */
    public AccessFilter addGreaterThan(String filterKey,Object filterValue){
        return addGreaterThan(true,filterKey,filterValue);
    }
    
    /**
     * 增加一个大于等于的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey 过滤字段
     * @param filterValue 过滤值
     * @return and 或者 or filterKey >= 'filterValue'
     */
    public AccessFilter addGreateThenAndEqual(boolean andCondition,String filterKey,Object filterValue){
    	this.filters.add(new AccessFilterGreaterThenAndEqualItem(andCondition,filterKey, filterValue));
        return this;
    }
    /**
     * 增加一个大于等于的过滤条件,默认使用 and 条件拼接
     * @param filterKey 过滤字段
     * @param filterValue 过滤值
     * @return and filterKey >= 'filterValue'
     */
    public AccessFilter addGreateThenAndEqual(String filterKey,Object filterValue){
        return addGreateThenAndEqual(true,filterKey,filterValue);
    }
    
    /**
     * 增加一个模糊匹配的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey    属性名称
     * @param filterValue  属性值
     * @param exactlyMatch 是否为全匹配
     * @return
     */
    public AccessFilter addLike(boolean andCondition,String filterKey, String filterValue, boolean exactlyMatch){
    	this.filters.add(new AccessFilterLikeItem(andCondition,filterKey, filterValue, exactlyMatch));
        return this;
    }
    /**
     * 增加一个模糊匹配的过滤条件,默认使用 and 条件拼接
     * @param filterKey    属性名称
     * @param filterValue  属性值
     * @param exactlyMatch 是否为全匹配
     * @return
     */
    public AccessFilter addLike(String filterKey,String filterValue,boolean exactlyMatch){
        return addLike(true,filterKey, filterValue, exactlyMatch);
    }
    
    /**
     * 增加一个以filterValue为开始的匹配的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey 属性名称
     * @param filterValue 属性值,开始字符
     * @return
     */
    public AccessFilter addStartWith(boolean andCondition,String filterKey,Object filterValue) {
    	this.filters.add(new AccessFilterStartWithItem(andCondition,filterKey, filterValue));
        return this;
    }
    /**
     * 增加一个以filterValue为开始的匹配的过滤条件,默认使用 and 条件拼接
     * @param filterKey 属性名称
     * @param filterValue 属性值,开始字符
     * @return
     */
    public AccessFilter addStartWith(String filterKey,Object filterValue) {
        return addStartWith(true,filterKey, filterValue);
    }
    
    /**
     * 增加一个以filterValue为结尾的匹配的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey 属性名称 
     * @param filterValue 属性值,结尾字符
     * @return
     */
    public AccessFilter addEndWith(boolean andCondition,String filterKey,Object filterValue) {
    	this.filters.add(new AccessFilterEndWithItem(andCondition,filterKey, filterValue));
        return this;
    }

    /**
     * 增加一个以filterValue为结尾的匹配的过滤条件,默认使用 and 条件拼接
     * @param filterKey 属性名称
     * @param filterValue  属性值,结尾字符
     * @return
     */
    public AccessFilter addEndWith(String filterKey,Object filterValue) {
        return addEndWith(true,filterKey, filterValue);
    }

    /**
     * 增加一个以范围为匹配的过滤条件
     * @param andCondition  使用 and 或者 or 条件拼接
     * @param filterKey 属性名称
     * @param filterValue1 起始值
     * @param filterValue2 结束值
     * @return
     */
    public AccessFilter addBetween(boolean andCondition,String filterKey,Object filterValue1,Object filterValue2){
        this.filters.add(new AccessFilterBetweenItem(andCondition,filterKey,filterValue1,filterValue2));
        return this;
    }
    /**
     * 增加一个以范围为匹配的过滤条件,默认使用 and 条件拼接
     * @param filterKey 属性名称
     * @param filterValue1 起始值
     * @param filterValue2 结束值
     * @return
     */
    public AccessFilter addBetween(String filterKey,Object filterValue1,Object filterValue2){
        return addBetween(true,filterKey,filterValue1,filterValue2);
    }

    /**
     * 通过一组map拼凑出 满足所有相等条件的过滤
     * @param andCondition 使用 and 或者 or 条件拼接
     * @param params 拼接的条件
     * @return
     */
    public AccessFilter addAllEqual(boolean andCondition, Map<String, Object> params){
        if(!(params == null || params.isEmpty())){
//            Iterator iterator = params.entrySet().iterator();
//            while(iterator.hasNext()) {
//                Map.Entry<String, Object> entry = (Map.Entry)iterator.next();
//                Object value = entry.getValue();
//                String key   = entry.getKey();
//                this.filters.add(new AccessFilterEqualItem(andCondition,key, value));
//            }
            params.forEach((k,v)->{
                this.filters.add(new AccessFilterEqualItem(andCondition,k, v));
            });
        }
        return this;
    }

    /**
     * 通过一组map拼凑出 满足所有相等条件的过滤
     * @param params 拼接的条件
     * @return
     */
    public AccessFilter addAllEqual(Map<String, Object> params){
        return  addAllEqual(true,params);
    }


    public AccessFilter addNewFilter(AccessFilterAddNewItem filterNew){
        this.filters.add(filterNew);
        return this;
    }

    @Override
    public String toString(){
    	StringBuilder sb = new StringBuilder("'__PLACEHOLDER' = '__PLACEHOLDER'");
    	for(int i = 0 ; i< filters.size();i++){
    		AccessFilterItem item = (AccessFilterItem) filters.get(i) ;
    		//sb.append(" and ");
    		sb.append(item);
    	}
    	return sb.toString().trim();
    }
    
}








	 
	 
	 

